home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 126-150 / disk_136 / paste / paste.c < prev    next >
C/C++ Source or Header  |  1992-05-06  |  12KB  |  509 lines
  1. /*
  2.  * paste - a recreation of the Unix(Tm) paste(1) command.
  3.  *
  4.  * syntax:    paste file1 file2 ...
  5.  *        paste -dLIST file1 file2 ...
  6.  *        paste -s [-dLIST] file1 file2 ...
  7.  *
  8.  *    Copyright (C) 1984 by David M. Ihnat
  9.  *
  10.  * This program is a total rewrite of the Bell Laboratories Unix(Tm)
  11.  * command of the same name, as of System V.  It contains no proprietary
  12.  * code, and therefore may be used without violation of any proprietary
  13.  * agreements whatsoever.  However, you will notice that the program is
  14.  * copyrighted by me.  This is to assure the program does *not* fall
  15.  * into the public domain.  Thus, I may specify just what I am now:
  16.  * This program may be freely copied and distributed, provided this notice
  17.  * remains; it may not be sold for profit without express written consent of
  18.  * the author.
  19.  * Please note that I recreated the behavior of the Unix(Tm) 'paste' command
  20.  * as faithfully as possible, with minor exceptions (noted below); however,
  21.  * I haven't run a full set of regression * tests.  Thus, the user of
  22.  * this program accepts full responsibility for any effects or loss;
  23.  * in particular, the author is not responsible for any losses,
  24.  * explicit or incidental, that may be incurred through use of this program.
  25.  *
  26.  * The changes to the program, with one exception, are transparent to
  27.  * a user familiar with the Unix command of the same name.  These changes
  28.  * are:
  29.  *
  30.  * 1) The '-s' option had a bug in the Unix version when used with multiple
  31.  *    files.  (It would repeat each file in a list, i.e., for
  32.  *    'paste -s file1 file2 file3', it would list
  33.  *    <file1\n><file1\n><file2\n><file1\n><file2\n><file3\n>
  34.  *    I fixed this, and reported the bug to the providers of the command in
  35.  *    Unix.
  36.  *
  37.  * 2) The list of valid escape sequences has been expanded to include
  38.  *    \b,\f, and \r.  (Just because *I* can't imagine why you'd want
  39.  *    to use them doesn't mean I should keep them from you.)
  40.  *
  41.  * 3) There is no longer any restriction on line length.
  42.  *
  43.  * I ask that any bugs (and, if possible, fixes) be reported to me when
  44.  * possible.  -David Ihnat (312) 784-4544 ihuxx!ignatz
  45.  */
  46.  
  47. /* Modified to run under MINIX 1.1
  48.  * by David O. Tinker  (416) 978-3636 (utgpu!dtinker)
  49.  * Sept. 19, 1987
  50.  */
  51.  
  52. #include <stdio.h>
  53. #include <errno.h>  /* make sure errno.h is available */
  54. #include <ctype.h>  /* make sure ctype.h is available */
  55.  
  56. extern int errno;
  57.  
  58. #ifndef unix
  59. #define _cleanup()  fflush(stdout)
  60. #endif
  61.  
  62. #define MINIX   /* as opposed to C86, or AZTEC in my case */
  63.         /* just in case I want to compile under DOS sometime */
  64.  
  65. /* I'd love to use enums, but not everyone has them.  Portability, y'know. */
  66. #define NODELIM        1
  67. #define USAGE        2
  68. #define BADFILE        3
  69. #define TOOMANY        4
  70.  
  71. #define    TAB        '\t'
  72. #define    NL        '\n'
  73. #define    BS        '\b'
  74. #define    FF        '\f'
  75. #define    CR        '\r'
  76. #define DEL             '\177'
  77.  
  78. #define    _MAXSZ        512
  79. #define _MAXFILES    12
  80. #define    CLOSED        ((FILE *)-1)
  81. #define ENDLIST        ((FILE *)-2)
  82.  
  83. char *cmdnam;
  84.  
  85. #undef toupper        /* Just in case it is a macro */
  86. static char toupper();
  87.  
  88. short int dflag,sflag;
  89. char delims[] = { TAB };
  90.  
  91. main(argc,argv)
  92. int argc;
  93. char **argv;
  94. {
  95.     char *strcpy();
  96.  
  97.     dflag = sflag = 0;
  98.  
  99.     cmdnam = *argv;
  100.  
  101.   if(argc >= 2) {
  102.  
  103.     /* Skip invocation name */
  104.     argv++;
  105.     argc--;
  106.  
  107.     /* First, parse input options */
  108.  
  109.     while(argv[0][0] == '-' && argv[0][1] != '\0')
  110.     {
  111.         switch(toupper(argv[0][1]))
  112.         {
  113.             case 'D':
  114.                 /* Delimiter character(s) */
  115.                 strcpy(delims,&argv[0][2]);
  116.                 if(*delims == '\0')
  117.                     prerr(NODELIM,"");
  118.                 else
  119.                     delimbuild(delims);
  120.  
  121.                 break;
  122.  
  123.             case 'S':
  124.                 sflag++;
  125.                 break;
  126.  
  127.             default:
  128.                 prerr(USAGE,"");
  129.         }
  130.         argv++;
  131.         argc--;
  132.     }
  133.   }
  134.  
  135.   else
  136.         prerr(USAGE,"");
  137.  
  138.     /*
  139.      * If no files specified, simply exit.  Otherwise,
  140.      * if not the old '-s' option, process all files.
  141.      * If '-s', then process files one-at-a-time.
  142.      */
  143.     if(!sflag)
  144.         docol(argc,argv); /* Column paste */
  145.     else
  146.         doserial(argc,argv);    /* Serial paste */
  147.  
  148.         _cleanup();
  149.         exit(0);
  150. } 
  151.  
  152. docol(nfiles,fnamptr)
  153. int nfiles;
  154. char **fnamptr;
  155. {
  156.     char iobuff[_MAXSZ];    /* i/o buffer for the fgets */
  157.     short int somedone;    /* flag for blank field handling */
  158.  
  159.     /*
  160.      * There is a strange case where all files are just ready to
  161.      * be closed, or will on this round.  In that case, the string
  162.      * of delimiters must be preserved.  delbuf[1] ->delbuf[MAXFILES+1]
  163.      * provides intermediate storage for closed files, if needed;
  164.      * delbuf[0] is the current index.
  165.      */
  166.     char delbuf[_MAXFILES+2];
  167.  
  168.     FILE *fileptr[_MAXFILES+1];
  169.     FILE *fopen();
  170.  
  171.     char *fgets();
  172.  
  173.     int filecnt;            /* Set to number of files to process */
  174.     register char *delimptr;    /* Cycling delimiter pointer */
  175.     int index;            /* Working variable */
  176.     int strend;            /* End of string in buffer */
  177.  
  178.     /*
  179.      * Perform column paste.  First, attempt to open all
  180.      * files. (This could be expanded to an infinite number of files,
  181.      * but at the (considerable) expense of remembering the file and
  182.      * its current offset, then opening/reading/closing.  The
  183.      * commands' utility doesn't warrant the effort; at least, to me...)
  184.      */
  185.  
  186.     for(filecnt=0;(nfiles>0) && (filecnt<_MAXFILES);filecnt++,nfiles--,fnamptr++)
  187.     {
  188.         if(fnamptr[0][0] == '-')
  189.             fileptr[filecnt] = stdin;
  190.         else
  191.         {
  192.             fileptr[filecnt] = fopen(*fnamptr,"r");
  193.             if(fileptr[filecnt] == NULL)
  194.                 prerr(BADFILE,*fnamptr);
  195.         }
  196.     }
  197.  
  198.     fileptr[filecnt] = ENDLIST;    /* End of list. */
  199.  
  200.     if(nfiles)
  201.         prerr(TOOMANY,"");
  202.  
  203.     /*
  204.      * Have all files.  Now, read a line from each file, and output
  205.      * to stdout.  Notice that the old 511 character limitation on
  206.      * the line length no longer applies, since this program doesn't
  207.      * do the buffering.  Do this until you go through the loop and
  208.      * don't successfully read from any of the files.
  209.      */
  210.     for(;filecnt;)
  211.     {
  212.         somedone = 0;        /* Blank field handling flag */
  213.         delimptr = delims;    /* Start at beginning of delim list */
  214.         delbuf[0] = 0;        /* No squirreled delims */
  215.  
  216.         for(index = 0;(fileptr[index] != ENDLIST) && filecnt; index++)
  217.         {
  218.             /* Read a line and immediately output.
  219.              * If it's too big for the buffer, then dump what was
  220.              * read and go back for more.
  221.              *
  222.              * Otherwise, if it is from the last file, then leave
  223.              * the carriage return in place; if not, replace with
  224.              * a delimiter (if any)
  225.              */
  226.  
  227.             strend = 0;    /* Set so can easily detect EOF */
  228.  
  229.             if(fileptr[index] != CLOSED)
  230.  
  231.                 while(fgets(iobuff,(_MAXSZ-1),fileptr[index]) != (char *)NULL)
  232.                 {
  233.                     strend = strlen(iobuff);    /* Did the buffer fill? */
  234.  
  235.                     if(strend == (_MAXSZ-1))
  236.                     {
  237.                         /* Gosh, what a long line. */
  238.                         fputs(iobuff,stdout);
  239.                         strend = 0;
  240.                         continue;
  241.                     }
  242.  
  243.                     /* Ok got whole line in buffer. */
  244.                     break;    /* Out of loop for this file */
  245.                 }
  246.  
  247.             /* Ended either on an EOF (well, actually NULL return--
  248.              * it *could* be some sort of file error, but
  249.              * but if the file was opened successfully, this is
  250.              * unlikely. Besides, error checking on streams
  251.              * doesn't allow us to decide exactly what went
  252.              * wrong, so I'm going to be very Unix-like and ignore
  253.              * it!), or a closed file, or a received line.
  254.              * If an EOF, close the file and mark it in the
  255.              * list.  In any case, output the delimiter of choice.
  256.              */
  257.  
  258.             if(!strend)
  259.             {
  260.                 if(fileptr[index] != CLOSED)
  261.                 {
  262.                     fclose(fileptr[index]);
  263.                     fileptr[index] = CLOSED;
  264.                     filecnt--;
  265.                 }
  266.  
  267.                 /* Is this the end of the whole thing? */
  268.                 if((fileptr[index+1] == ENDLIST) && !somedone)
  269.                     continue; /* EXITS */
  270.  
  271.                 /* Ok, some files not closed this line. Last file? */
  272.                 if(fileptr[index+1] == ENDLIST)
  273.                 {
  274.                     if(delbuf[0])
  275.                     {
  276.                         fputs(&delbuf[1],stdout);
  277.                         delbuf[0] = 0;
  278.                     }
  279.                     putc((int)NL,stdout);
  280.                     continue;    /* Next read of files */
  281.                 }else
  282.                 {
  283.                     /* Closed file; setup delim */
  284.                     if(*delimptr != DEL)
  285.                     {
  286.                         delbuf[0]++;
  287.                         delbuf[delbuf[0]] = *delimptr++;
  288.                         delbuf[delbuf[0]+1] = '\0';
  289.                     }else
  290.                         delimptr++;
  291.                 }
  292.  
  293.                 /* Reset end of delimiter string if necessary */
  294.                 if(*delimptr == '\0')
  295.                     delimptr = delims;
  296.             }else
  297.             {
  298.                 /* Some data read. */
  299.                 somedone++;
  300.  
  301.                 /* Any saved delims? */
  302.                 if(delbuf[0])
  303.                 {
  304.                     fputs(&delbuf[1],stdout);
  305.                     delbuf[0] = 0;
  306.                 }
  307.  
  308.                 /* If last file, last char will be NL. */
  309.                 if(fileptr[index+1] != ENDLIST)
  310.                 {
  311.                     if(*delimptr == DEL)
  312.                     {
  313.                         delimptr++;
  314.                         iobuff[strend-1] = '\0'; /* No delim */
  315.                     }else
  316.                         iobuff[strend-1] = *delimptr++;
  317.                 }
  318.  
  319.                 if(*delimptr == '\0')
  320.                     delimptr = delims;
  321.  
  322.                 /* Now dump the buffer */
  323.                 fputs(iobuff,stdout);
  324.                 _cleanup();
  325.             }
  326.         }
  327.     }
  328. }
  329.  
  330. doserial(nfiles,fnamptr)
  331. int nfiles;
  332. char **fnamptr;
  333. {
  334.     /*
  335.      * Do serial paste.  Simply scarf characters, performing
  336.      * one-character buffering to facilitate delim processing.
  337.      */
  338.     
  339.     register int charnew,charold;
  340.     register char *delimptr;
  341.  
  342.     register FILE *fileptr;
  343.     FILE *fopen();
  344.  
  345.     for(;nfiles;nfiles--,fnamptr++)
  346.     {
  347.         if(fnamptr[0][0] == '-')
  348.             fileptr = stdin;
  349.         else
  350.         {
  351.             fileptr = fopen(*fnamptr,"r");
  352.  
  353.             if(fileptr == NULL)
  354.                 prerr(BADFILE,*fnamptr);
  355.         }
  356.  
  357.         /*
  358.          * The file is open; just keep taking characters,
  359.          * stashing them in charnew; output charold, converting to
  360.          * the appropriate delimiter character if needful.  After the
  361.          * EOF, simply output 'charold' if it's a newline; otherwise,
  362.          * output it and then a newline.
  363.          */
  364.  
  365.         delimptr = delims;    /* Set up for delimiter string */
  366.  
  367.         if((charold = getc(fileptr)) == EOF)
  368.         {
  369.             /* Empty file! */
  370.             putc(NL,stdout);
  371.             _cleanup();
  372.             continue;    /* Go on to the next file */
  373.         }
  374.  
  375.         /* Ok, 'charold' is set up.  Hit it! */
  376.  
  377.         while((charnew = getc(fileptr)) != EOF)
  378.         {
  379.             /* Ok, process the old character */
  380.             if(charold == NL)
  381.             {
  382.                 if(*delimptr != DEL)
  383.                     putc(*delimptr++,stdout);
  384.  
  385.                 /* Reset pointer at end of delimiter string */
  386.                 if(*delimptr == '\0')
  387.                     delimptr = delims;
  388.             } else
  389.                 putc((char)charold,stdout);
  390.             
  391.             charold = charnew;
  392.         }
  393.  
  394.         /* Ok, hit EOF.  Process that last character */
  395.  
  396.         putc((char)charold,stdout);
  397.         _cleanup();
  398.         if((char)charold != NL)
  399.             putc(NL,stdout);
  400.     }
  401. }
  402.  
  403. delimbuild(strptr)
  404. char *strptr;
  405. {
  406.     /*
  407.      * Process the delimiter string into something that can be
  408.      * used by the routines.  This involves, primarily, collapsing
  409.      * the backslash representations of special characters into
  410.      * their actual values, and terminating the string in a manner
  411.      * that the routines can recognize.  The set of possible backslash
  412.      * characters has been expanded beyond that recognized by the
  413.      * vanilla Unix(Tm) version.
  414.      */
  415.  
  416.     register char *strout;
  417.  
  418.     strout = strptr;    /* Start at the same place, anyway */
  419.  
  420.     while(*strptr)
  421.     {
  422.         if(*strptr != '\\')    /* Is it an escape character? */
  423.             *strout++ = *strptr++;    /* No, just transfer it */
  424.         else
  425.         {
  426.             strptr++;    /* Get past escape character */
  427.  
  428.             switch(toupper(*strptr))
  429.             {
  430.                 case '0':
  431.                     *strout++ = DEL;
  432.                     break;
  433.  
  434.                 case 'T':
  435.                     *strout++ = TAB;
  436.                     break;
  437.  
  438.                 case 'N':
  439.                     *strout++ = NL;
  440.                     break;
  441.  
  442.                 case 'B':
  443.                     *strout++ = BS;
  444.                     break;
  445.  
  446.                 case 'F':
  447.                     *strout++ = FF;
  448.                     break;
  449.  
  450.                 case 'R':
  451.                     *strout++ = CR;
  452.                     break;
  453.  
  454.                 default:
  455.                     *strout++ = *strptr;
  456.             }
  457.             
  458.             strptr++;
  459.         }
  460.  
  461.     }
  462.     *strout = '\0';    /* Heaven forfend that we forget this! */
  463. }
  464.  
  465. prerr(etype, estring)
  466. int etype;
  467. char *estring;
  468. {
  469.     switch(etype)
  470.     {
  471.         case USAGE:
  472.             fprintf(stderr,"%s : Usage: %s [-s] [-d<delimiter>] file1 file2 ...\n",cmdnam,cmdnam);
  473.             break;
  474.  
  475.         case NODELIM:
  476.             fprintf(stderr,"%s : no delimiters\n",cmdnam);
  477.             break;
  478.  
  479.         case BADFILE:
  480.             fprintf(stderr,"%s : %s : cannot open\n",cmdnam,estring);
  481.             break;
  482.         
  483.         case TOOMANY:
  484.             fprintf(stderr,"%s : too many files\n",cmdnam);
  485.             break;
  486.     }
  487.     _cleanup();
  488.     exit(1);
  489. }
  490.  
  491. static char toupper(c)            /* This is non-standard, but it works */
  492. char c;
  493. {
  494.    char x;
  495.  
  496.    if (isalpha(c)) {
  497.       if (c > 'Z') x = (c - ' ');
  498.       else x = c;
  499.    }
  500.    else {
  501.       if (isdigit(c))
  502.           x = c;
  503.       else x = '\0';        /* this will terminate a string
  504.                  * at any character other than a
  505.                  * letter or numeral.            */ 
  506.    }
  507.    return (x);
  508. }
  509.